/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package membresia.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 *
 * @author rodrigo.rezende
 */
public class Service {

    // método que retorna um entity mananger factory
    public static EntityManager getEntityManagerFactory() {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("membresiaMySQL");
        return emf.createEntityManager();
    }

    /**
     * Realiza a validação do cpf. O CPF é composto por onze algarismos, onde os
     * dois últimos são chamados de dígitos verificadores, ou seja, os dois
     * últimos dígitos são criados a partir dos nove primeiros. O cálculo é
     * feito em duas etapas utilizando o módulo de divisão 11. Para exemplificar
     * melhor, iremos calcular os dígitos verificadores de um CPF imaginário,
     * por exemplo, 222.333.666-XX. Fazendo o cálculo do primeiro dígito
     * verificador O primeiro dígito é calculado com a distribuição dos dígitos
     * colocando-se os valores 10, 9, 8, 7, 6, 5, 4, 3, 2 conforme a
     * representação abaixo: Números do CPF: 2 2 2 3 3 3 6 6 6 Valores definidos
     * para o calculo 10 9 8 7 6 5 4 3 2 Na sequência multiplicaremos os valores
     * de cada coluna, confira: Total 20 18 16 21 18 15 24 18 12 Em seguida
     * efetuaremos o somatório dos resultados (20+18+...+18+12), o resultado
     * obtido (162) será divido por 11. Considere como quociente apenas o valor
     * inteiro, o resto da divisão será responsável pelo cálculo do primeiro
     * dígito verificador. Vamos acompanhar: 162 dividido por 11 obtemos 14 de
     * quociente e 8 de resto da divisão. Caso o resto da divisão seja menor que
     * 2, o nosso primeiro dígito verificador se torna 0 (zero), caso contrário
     * subtrai-se o valor obtido de 11, que é nosso caso, sendo assim nosso
     * dígito verificador é 11-8, ou seja, 3 (três), já temos parte do CPF,
     * confira: 222.333.666-3X. Fazendo o cálculo do segundo dígito verificador
     * Para o cálculo do segundo dígito será usado o primeiro dígito verificador
     * já calculado. Montaremos uma tabela semelhante à anterior, só que desta
     * vez usaremos na segunda linha os valores 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,
     * já que estamos incorporando mais um algarismo para esse cálculo. Veja:
     * Números do CPF 2 2 2 3 3 3 6 6 6 3 Valores definidos para o calculo 11 10
     * 9 8 7 6 5 4 3 2 Na próxima etapa faremos como na situação do cálculo do
     * primeiro dígito verificador. Multiplicaremos os valores de cada coluna e
     * efetuaremos o somatório dos resultados obtidos:
     * 22+20+18+24+21+18+30+24+18+4=201. Números do CPF: 2 2 2 3 3 3 6 6 6 3
     * Valores definidos para o calculo : 11 10 9 8 7 6 5 4 3 2 Total 22 20 18
     * 24 21 18 30 24 18 6 Agora pegamos esse valor e dividimos por 11.
     * Considere novamente apenas o valor inteiro do quociente, e com o resto da
     * divisão, no nosso caso 3, usaremos para o cálculo do segundo dígito
     * verificador, assim como na primeira parte. Caso o valor do resto da
     * divisão seja menor que 2, esse valor passa automaticamente a ser zero,
     * que é o nosso caso, caso contrário é necessário subtrair o valor obtido
     * de 11 para se obter o dígito verificador. Neste caso chegamos ao final
     * dos cálculos e descobrimos que os dígitos verificadores do nosso CPF
     * hipotético são os números 3 e 8, portanto o CPF ficaria assim:
     * 222.333.666-38.      *
     * @param strCPF número de cpf a ser validado
     * @return true se o cpf é válido e false se não é válido
     */
    public static boolean validaCpf(String cpf) {
        String strCpf = cpf;
        // declaração das variaveis
        int d1, d2;
        int digito1, digito2, resto;
        int digitoCpf;
        String nDigResult;

        d1 = d2 = 0;
        digito1 = digito2 = resto = 0;

        // verifica se é númerico
        try {
            Long temp = Long.parseLong(cpf);
        } catch (NumberFormatException e) {
            return false;
        }
        // verifica se o cpf possui sequencias numéricas não permitidas
        if (cpf.equals("00000000000") || cpf.equals("11111111111")
                || cpf.equals("22222222222") || cpf.equals("33333333333")
                || cpf.equals("44444444444") || cpf.equals("55555555555")
                || cpf.equals("66666666666") || cpf.equals("77777777777")
                || cpf.equals("88888888888") || cpf.equals("99999999999")
                || (cpf.length() != 11)) {
            return (false);
        }
        // percorre os caracteres do cpf
        for (int nCount = 1; nCount < strCpf.length() - 1; nCount++) {
            digitoCpf = Integer.valueOf(strCpf.substring(nCount - 1, nCount)).intValue();
            //multiplique a ultima casa por 2 a seguinte por 3 a seguinte por 4 e assim por diante.  
            d1 = d1 + (11 - nCount) * digitoCpf;
            //para o segundo digito repita o procedimento incluindo o primeiro digito calculado no passo anterior.  
            d2 = d2 + (12 - nCount) * digitoCpf;
        }
        //Primeiro resto da divisão por 11.  
        resto = (d1 % 11);
        //Se o resultado for 0 ou 1 o digito é 0 caso contrário o digito é 11 menos o resultado anterior.  
        if (resto < 2) {
            digito1 = 0;
        } else {
            digito1 = 11 - resto;
        }
        d2 += 2 * digito1;
        //Segundo resto da divisão por 11.  
        resto = (d2 % 11);
        //Se o resultado for 0 ou 1 o digito é 0 caso contrário o digito é 11 menos o resultado anterior.  
        if (resto < 2) {
            digito2 = 0;
        } else {
            digito2 = 11 - resto;
        }
        //Digito verificador do cpf que está sendo validado.  
        String nDigVerific = strCpf.substring(strCpf.length() - 2, strCpf.length());
        //Concatenando o primeiro resto com o segundo.  
        nDigResult = String.valueOf(digito1) + String.valueOf(digito2);
        //comparar o digito verificador do cpf com o primeiro resto + o segundo resto.  
        return nDigVerific.equals(nDigResult);
    }
}
